Computer Programming – The Rules of the Game
A basis of a vector space is a set of vectors in that space that can be used as coordinates for it. [1]
I just read Dan Meyer‘s quick review of the Graspable Math tool. While I did briefly investigate Graspable Math, and also glanced at Desmos, the tool where Dan is head of teaching, what really struck me was how Dan’s writing shows him to be “on the inside” of math teaching and learning. As I am too. That is, there’s a room called “math”, both of us are inside it, and we’re familiar with the rules of the game.
As I love computer programming and am always looking for new ways to teach it, the question arose in my mind: what is the minimal set of constructs to teach students so that they can take off from there and learn the rest of computer programming, in any language, pretty much by themselves?
I did a quick search for “minimal constructs of programming” and found Software Design & Development: Programming Constructs (pdf) from The High School of Dundee in Scotland. Nice and clear, but according to the table of contents, roughly 30 topics. That feels like too many to be minimal.
When faced with the question of how to teach, I usually first turn back to myself – how do I learn? That answer is not likely to be the best or complete answer, because most students are not me. (A valuable lesson for teachers, that I struggle to keep in mind!) But it’s an OK start, and often it’s all I have.
When I learn a new programming language, what constructs do I look for?
- Variables (scalars, vectors; and assignment – same “=” sign means something very different from math)
- Operators (may look very different in, say, Python vs APL vs AWK)
- Conditionals
- Loops
- Input/Output
- Functions (could be an intermediate level topic, but so important for clear code that I put it here)
Maybe also
- Imports (to get access to additional commands)
- Classes (for object-oriented programming — question whether that’s an essential or advanced topic)
And there’s also environment and tools:
- How to edit
- How to compile (if necessary)
- How to run (both in editor and from command line — so “command line” is a concept too)
- How to interact with the program (where do I put input? where do I see output?)
The absolute minimum count of the above is 10 topics. Is that the minimum? Is that the right set? And, is it a set of topics where each one makes sense to a student who is new to computer programming? That last one is so important because (as above), my students are not me.
Thus, towards a second draft of the list, and maybe some hints to what kinds of explanations, exercises, and even learning-support tools (like the math environments mentioned at the beginning of this post, only for computer programming), I want to consider the question in some new ways. Based less on how I learn computer programming, and more on how people, even children, learn things from each other:
If computer programming were an outdoor game played at recess, and I were ten years old, how would I teach my friends the rules of the game?
If computer programming were a dance, what would be the basic steps?
What are your answers to these questions?
Insights from a Broken Calculator
Declaring the end from the beginning, and from ancient times things that are not yet done; saying: ‘My counsel shall stand, and all My pleasure will I do’
(Isaiah 46:10)
In elementary school we learned about numbers as if they were only for counting and calculating, skipping right over all the beauty of numbers and their meaning. So I was happy to have this “Calculator Puzzle” brought to my attention via a Twitter post. Not just for the mental exercise, but for the insights it brought about different parts of math (calculation, algebra, and geometry) to name a few, and about how my mind progresses from problem to solution. Definitely not by a straight line. But also not by a random walk.
Spolier Alert:
If you want to try to solve the problems yourself, do NOT read this post, nor my replies on the Twitter thread!
That said, here was my thought process:
Background
calculator is not working properly. Only the add and reciprocal buttons work, as well as the numbers 0-9.
Well that was interesting. Reciprocal is not a key that I often use on a calculator.
Question 1
Can you work out how to halve any number?
I admit, my first reaction, and the one I went with, was to try a specific example first. And, as above in Isaiah, to “declare the end from the beginning”.
Say, half of 5. That would be 5/2.
How could I get from “5” and “half” to 5/2, with only “+” and “1/x”?
Impressed by the unusual button — reciprocal — I immediately asked: could I get 2/5?
Well, yes. 1/5 + 1/5 is 2/5.
That was it: 5, 1/x, +, 5, 1/x, = would give 2/5. Another press on 1/x would give 5/2. Q.E.D.
Insight 1a*
Better than solving the problem, though, is that as an electrical engineer, I felt a sense of “coming home”. I hadn’t seen it at first, but this was “reciprocal of the sum of the reciprocals”. Well known as the resistance of a set of resistors in parallel. So it would certainly work for every case, because two equal resistors is two equal paths instead of one, offering half the resistance. Whether you feel that math or electricity is the original depends on whether you’re a mathematician or an engineer.
* Where’s 1b?? You’ll have to wait for that. I did.
Question 2
Now the subtract button has started working.
I think this means I can now square any number – can you work out how?
Here, I rushed ahead too quickly to generalize. I offered a solution where squaring is a special case of multiplication. The original questioner gently encouraged me to try again without repeated addition.
Back to my specific example. 5. 5 squared is 25. No way I would get directly to 25, but now that I was friends with that reciprocal button, I sought 1/25.
After a few minutes of that, I realized that I would have to use the “-” button. Surely it was working (in the problem) for a reason.
1/25 is pretty small. I would get it by subtracting fractions (which I could generate with the 1/x button). But I couldn’t think of any fractions to subtract, certainly not with a numerator of 1, that would yield 1/25. I did realize that fractions with denominators close to each other would yield significantly smaller fractions. How about 1/4 – 1/5 = 1/20. OK, 1/20 was not 1/25, but maybe I could fix it up. 1/20 would yield 20 (after pressing 1/x). Then simple enough to add 5 and get to 25.
5 squared = 5 + 1 / (1/4 – 1/5).
I generalized: n^2 = n + 1 / (1/(n-1) – 1/n)
Why would it work in general? Algebra:
n + 1 / ( (n – (n-1)) / (n(n-1))) = n + 1 / 1 / (n(n-1)) = n + n(n-1) = n + n^2 – n = n^2.
Q.E.D. again.
Insight 2
Why is 1/4 – 1/5 = 1/20? What’s special there? Suddenly, though I had never seen it written down, I thought: “Consecutive integers are relatively prime.” Then I looked that up to be sure. I read some proof discussions, and then left off that to continue the problem.
Question 3
Now, I think I can also calculate the product of any number. How?
Here, I was onto the power of algebra to solve problems “automatically”. Instead of one number n, I would have two numbers x and y. I asked myself what product expressions involving x and y I was familiar with. The product (x+y)(x-y) came to mind. In high school it always seemed nice because it produced a sum of squares “cleanly” with no annoying middle term in xy. But here, I realized, “xy” was just what I was looking for. So the product would be the “messier” one: (x+y)(x+y). Which, by the way, is (x+y)^2. Aha! Is this is why the problem author tried to take me by the hand from square to product?
Anyway, (x+y)(x+y) = x^2 + 2xy + y^2. That could be solved for xy:
xy = ((x+y)(x+y)-(x^2 + y^2))/2.
Insight 3
I like geometrical interpretations more than, or at least in addition to, purely algebraic interpretations. Even if algebra works, I feel better seeing a picture too. So I went back and asked myself what picture matched that equation. Here it is (freehand drawing):
Insight 1b
Now, even though I had solved question 1 without any algebraic symbols, I challenged myself to find a geometric interpretation for the reciprocal of the sum of the reciprocals, with two equal numbers yielding a half.
One geometric interpretation of reciprocal is the (negative of the) slope of the perpendicular. With that in mind, the picture came pretty quickly:
Question 4
Are there any other operations I can do with only add, subtract and reciprocal?
I left this for when I find more time. Or maybe a reader would like to offer some thoughts? Not just the “answers”, but your thought process, and any insights that come up for you!
Writing, Unschooled
(credit: Google search “prompt definition”)
“Leap, please,” cried the young orangutan, holding onto his mother’s feral arm.
Learning a New Programming Language, with Life (part 4)
While preparing a course syllabus on coding in Python, for an upcoming high school class, I remembered static analysis. I haven’t decided how soon to introduce the topic, but I thought I’d better check how my own sample program fared.
No warnings or errors from Python itself. (If there had been I would have addressed them already!).
So I installed Pylint and tried its default settings. How about that. Not zero at all!
In fact, 54 coding convention messages, 12 warnings, and 1 recommendation for refactoring.
It was easy enough to clean up whitespace issues (helped to turn on “view whitespace” in my Notepad2).
And yes, many comment lines were too long. I left-justified (but indented for Python) for easy reading.
Some of the warnings are for my “TODO” comments — an extra reminder to do, or drop, next steps I’d identified earlier. Pylint message count is now down to 2 informational messages, 28 coding convention, 13 warnings, and 1 to refactor. They are valuable for my future Python learning (and teaching):
Locally disabling unused-variable (W0612) (locally-disabled)
I disabled those warnings because I know the code needs those variables. But I’ll have to explain why.
(Pylint doesn’t forget — the 2 new informational messages remind that I’ve suppressed two warnings.)
Invalid attribute name “maxRowMain” (invalid-name)
Not just that name. Most of my object names. I’ll have to find a good object-naming convention and use it.
R: 69, 4: Too many branches (13/12) (too-many-branches)
Just today I heard a Python lecturer on YouTube say, “if you’re not refactoring, you’re not learning.” Yes, that function is the longest. Not so complex, but could be simpler and easier to understand.
Attribute ‘maxRowMain’ defined outside __init__ (attribute-defined-outside-init)
A few of those also. I will have to go back and learn again about __init__: when to use it and why.
All in all, a good learning session, and direction on what I need to learn next.
Thanks to static analysis with Pylint.
Learning a New Programming Language, with Life (part 3)
I started learning Python three days ago, as described here in part 1 and part 2.
Just two hours a day, and I’m well on my way, because here below is a working implementation of my favorite, Conway’s Game of Life, in Python.
Today I refactored to put instance-specific initializations right in the functions that needed them, and promoted parsing of command line arguments to the main program. (Future: use argparse.)
I also realized that these functions are just procedures, so I stopped trying to return meaningful values. I removed the return statements. Python supports that, and returns None.
Update:
A day later, after questions from a reader led me to review my own code, I wondered why it works even without wraparound for negative indices!
The answer: Python lists handle negative indexes gracefully.
Let’s go to the code …
#Life.py
#Implementation of Conway’s Game of Life
#See https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life
#Tom Harris 22-Jul-2015
#Tom Harris 23-Jul-2015 add multiple generations and display period to main program
#Import libraries needed
import sys #for command line argument support
#Define the Life class
class Life:
….#class attributes
….#None
….#class methods
….#NOTE: Currently all procedures — no return statement, implicitly returns None
….
….def readBoardFromFile(self, filename):
……..#Initialize (clear) the board of Life cells
……..self.mainBoard = []
……..#Open the file
……..initialGenerationFile = open(filename)
……..#Read from the file, line by line:
……..for line in initialGenerationFile:
…………listLine = list(line.rstrip(‘\r\n’))
…………self.mainBoard.append(listLine) #add the line, in Python list format, to the mainBoard
……..#Determine dimensions of the board after reading in
……..#WARNING: dimensions are 1 larger than largest index, since indices start at 0
……..self.maxRowMain = len(self.mainBoard)
……..self.maxColMain = len(self.mainBoard[0])
……..#Close the file
……..initialGenerationFile.close
….def displayBoard(self):
……..for rowIndex, row in enumerate(self.mainBoard):
…………for colIndex, col in enumerate(row):
…………….if self.mainBoard[rowIndex][colIndex]== “1”:
………………..print(“X”, end=”)
…………….else:
………………..print(“.”, end=”)
…………print() #print newline at end of each row
….def makeBoardCurrent(self): #TODO: Think of a better name — means to copy from the next-generation workingBoard to mainBoard
……..self.mainBoard = self.workingBoard
……..
….def calculateNextGeneration(self):
……..#Calculate next generation on workingBoard based on mainBoard
……..#Initialize work area
……..self.workingBoard = [] #A work area for creating the next Life generation
……..#Calculate next generation on workingBoard based on mainBoard
……..for mainRowIndex, mainRow in enumerate(self.mainBoard):
…………#Initialize working row before using for each row
…………workingRow = [] #for building up workingBoard row by row
…………for mainColIndex, mainElement in enumerate(mainRow):
…………….#Restart count of live cells
…………….numLiveCells = 0
…………….for i in [-1, 0, 1]:
………………..#Check row before, same row, next row
………………..rowOfCellToCheck = mainRowIndex + i
………………..#Wraparound
………………..if rowOfCellToCheck (self.maxRowMain – 1):
……………………rowOfCellToCheck = 0
……………………
………………..for j in [-1, 0, 1]:
……………………#Check column before, same column, next column
……………………colOfCellToCheck = mainColIndex + j
……………………#Wraparound
……………………if colOfCellToCheck (self.maxColMain – 1):
……………………….colOfCellToCheck = 0
……………………#If cell to check is alive, increment count of live cells
……………………#But if same row and column, ignore
……………………sameColAndRow = abs(i) + abs(j)
……………………if sameColAndRow != 0:
……………………….if self.mainBoard[rowOfCellToCheck][colOfCellToCheck] == “1”:
………………………. numLiveCells = numLiveCells + 1
…………………………………………
…………….if self.mainBoard[mainRowIndex][mainColIndex] == “1”: # The survival rules
………………..if 2 <= numLiveCells <= 3:
……………………workingRow.append(‘1’)
………………..else:
……………………workingRow.append(‘0’)
…………….else: #The reproduction rule
………………..if numLiveCells == 3:
……………………workingRow.append(‘1’)
………………..else:
……………………workingRow.append(‘0’)
……………………
…………self.workingBoard.append(workingRow)
…………………………..
#The actual main Life program
#Usage will be Life(filename, generations to calculate, every how many generations to display, display yes/no, write to files yes/no)
#First Usage Life() — done 22-Jul 10:24
#Second Usage Life(filename) — reading in file done 22-Jul-2015 10:59
#Third Usage Life(filename) — including displaying the file and dummy next generation 22-Jul-2015 18:34
#Fourth Usage Life(filename) — real next generation done 22-Jul-2015 20:17
#Fifth Usage Life(filename, generations to calculate, every how many generations to display) done 23-Jul-2015 20:44
#NOTE: Decided not to implement writing single generations to separate files. Seems unnecessary and would just fill my disk with lots of files.
#NOTE: Piping console output to text file is fine. Modern text editors can open large, multi-generation Life files and navigate quickly
#TODO: Next learning topics (backlog) would be:
#….1. Graphic display
#….2. Mouse input of boards
#….3. Change to argparse for robust command line parsing
#….4. Clean up file layout according to some accepted Python style guide
#….5. Refactor to be more functional as opposed to procedural, and reduce global variable use, if that makes code clearer
#Create a single Life instance
myLife = Life()
#Get the command line arguments
#TODO:Switch to Python argparse module instead
#From first command line argument, get pathname of initial (zero’th) generation text file
initialGenerationFilename = sys.argv[1]
#From second command line argument, get number of generations to calculate
numGenerations = int(sys.argv[2])
#From third command line argument, get period: every how many generations to display or write to file
#NOTE: currently, writing results to a file is not yet included
periodOfDisplay = int(sys.argv[3])
#Read in the initial (zero’th) generation board from text file
myLife.readBoardFromFile(initialGenerationFilename)
#Display initial (zero’th) generation
print(“Generation #”,0)
myLife.displayBoard()
print()
#Generate and display following generations
for generationIndex in range(1,numGenerations+1): #NOTE:Add 1 because range end is always one less than value
….myLife.calculateNextGeneration()
….myLife.makeBoardCurrent()
….if (generationIndex % periodOfDisplay) == 0: #NOTE: “%” is Python modulus — checking for evening divisible by period of display
……..print(“Generation #”,generationIndex)
……..myLife.displayBoard()
……..print()
And here’s some output. The 4-generation-period “glider” on a 25 x 25 grid, starts its flight from upper-left towards lower-right.
The command I ran was
Life.py Glider25by25.txt 8 4
and the output was
Generation # 0
..X......................
...X.....................
.XXX.....................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
Generation # 4
.........................
...X.....................
....X....................
..XXX....................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
Generation # 8
.........................
.........................
....X....................
.....X...................
...XXX...................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
.........................
Learning a New Programming Language, with Life (part 2)
I started learning Python two days ago, as described in part 1.
Yesterday I learned about Python Classes and Functions, including class and instance variables, and the special __init__ function. Today I learned enumerate, and the list function rstrip. I also learned not to forget the colon (:) in def, for, if, and else constructs!
After just a few hours today, my first project has actually started working.
For one “generation”, according to the rules of Conway’s Game of Life.
Here it is, complete with TEST comments preceding debugging code, and TODO comments for what’s next.
#Life.py
#Implementation of Conway's Game of Life
#See https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life
#Tom Harris 22-Jul-2015
#Import libraries needed
import sys #for command line argument support
#Global functions
def initialGenerationFilename():
….#Get pathname from first command line argument
….return sys.argv[1]
#Define the Life class
class Life:
….#class attributes
….#None
….#class methods
….def __init__(self):
……..#instance attributes: define and initialize (some more later after reading in file)
……..self.mainBoard = [] #The board of cells
……..self.workingBoard = [] #A work area for creating the next Life generation
….
….def readBoardFromFile(self, filename):
……..#Open the file
……..initialGenerationFile = open(filename)
……..#Read from the file, line by line:
……..for line in initialGenerationFile:
…………listLine = list(line.rstrip(‘\r\n’))
…………self.mainBoard.append(listLine) #add the line, in Python list format, to the mainBoard
……..#Determine dimensions of the board after reading in
……..#WARNING: dimensions are 1 larger than largest index, since indices start at 0
……..self.maxRowMain = len(self.mainBoard)
……..self.maxColMain = len(self.mainBoard[0])
……..#Close the file
……..initialGenerationFile.close
……..return self.mainBoard
….def displayBoard(self):
……..for rowIndex, row in enumerate(self.mainBoard):
…………for colIndex, col in enumerate(row):
…………….if self.mainBoard[rowIndex][colIndex]== “1”:
………………..print(“*”, end=”)
…………….else:
………………..print(“.”, end=”)
…………print() #print newline at end of each row
……..return 0 #TODO: replace with returning a result — what do we do with it? This is a function, not a procedure.
….def makeBoardCurrent(self): #TODO: Think of a better name — means to copy from the next-generation workingBoard to mainBoard
……..self.mainBoard = self.workingBoard
……..
……..return self.mainBoard
….def calculateNextGeneration(self):
……..#Calculate next generation on workingBoard based on mainBoard
……..workingRow = [] #for building up workingBoard row by row
……..#Calculate next generation on workingBoard based on mainBoard
……..for mainRowIndex, mainRow in enumerate(self.mainBoard):
…………for mainColIndex, mainElement in enumerate(mainRow):
…………….#Restart count of live cells
…………….numLiveCells = 0
…………….for i in [-1, 0, 1]:
………………..#Check row before, same row, next row
………………..rowOfCellToCheck = mainRowIndex + i
………………..#Wraparound
………………..if rowOfCellToCheck < 0:
……………………rowOfCellToCheck = self.maxRowMain – 1
………………..if rowOfCellToCheck > (self.maxRowMain – 1):
……………………rowOfCellToCheck = 0
……………………
………………..for j in [-1, 0, 1]:
……………………#Check column before, same column, next column
……………………colOfCellToCheck = mainColIndex + j
……………………#Wraparound
……………………if colOfCellToCheck < 0:
……………………….colOfCellToCheck = self.maxColMain – 1
……………………if colOfCellToCheck > (self.maxColMain -1):
……………………….colOfCellToCheck = 0
……………………#If cell to check is alive, increment count of live cells
……………………#But if same row and column, ignore
……………………sameColAndRow = abs(i) + abs(j)
……………………if sameColAndRow != 0:
……………………….if self.mainBoard[rowOfCellToCheck][colOfCellToCheck] == “1”:
………………………. numLiveCells = numLiveCells + 1
…………………………………………
…………….if self.mainBoard[mainRowIndex][mainColIndex] == “1”: # The survival rules
………………..if 2 <= numLiveCells <= 3:
……………………workingRow.append(‘1’)
………………..else:
……………………workingRow.append(‘0’)
…………….else: #The reproduction rule
………………..if numLiveCells == 3:
……………………workingRow.append(‘1’)
………………..else:
……………………workingRow.append(‘0’)
……………………
…………self.workingBoard.append(workingRow)
…………workingRow = []
………………..
……..return self.workingBoard
#The actual main Life program
#Usage will be Life(filename, generations to calculate, every how many generations to display, display yes/no, write to files yes/no)
#First Usage Life() — done 22-Jul 10:24
#Second Usage Life(filename) — reading in file done 22-Jul-2015 10:59
#Third Usage Life(filename) — including displaying the file and dummy next generation 22-Jul-2015 18:34
#Fourth Usage Life(filename) — real next generation done 22-Jul-2015 20:17
#TODO: Fifth Usage Life(filename, generations to calculate, every how many generations to display)
#Create a single Life instance
myLife = Life()
#Run the methods in the right order
myLife.readBoardFromFile(initialGenerationFilename())
myLife.displayBoard() #TEST: display the mainBoard before generating
print()
myLife.calculateNextGeneration()
myLife.makeBoardCurrent()
myLife.displayBoard()
And here’s the output. It’s the simplest oscillator — the “Blinker”, one generation, with wraparound:
........
*.......
*.......
*.......
........
........
........
........
........
........
........
**.....*
........
........
........
........
........
........
Learning a New Programming Language, with Life
For an upcoming course to help science students master the computer as a tool for their work, by learning to code, I need to learn Python. I reviewed discussions on Python 2 vs Python 3, and chose the latter.
To operate in a new language, I only need to learn and practice four things:
- Input
- Storage and Retrieval
- Processing
- Output
(Wish I could program functionally, and avoid #2. But Python isn’t designed for functional programming.)
My traditional project for learning a new language is to code Conway’s Game of Life.
After my first 2 hours in Python, with Python 3.4.3 installed, and Google for answering my questions, I’ve covered command line arguments (though still without argparse for user error handling), input from text file, output to console, line-by-line storage, and character-by-character retrieval from a Python list.
I’ve also imported one Python module (sys), and gotten used to code blocks via indentation.
Here’s my code so far. Wish me luck as I continue learning!
#ReadTextFromFileAndDisplay.py
#Import libraries needed
import sys #for command line argument support
#Get pathname of file to open from first command line argument
filenameToOpen = sys.argv[1]
#Open the file
myFile = open(filenameToOpen)
print("Pathname was: ", filenameToOpen)
print("Result code for opening the file was: \n", myFile)
#Read and display entire file
#Also store it in a list
myList = [] #declare list, initially empty
print("\nHere is the file as it's being read in: \n")
#Read from the file, line by line:
for line in myFile:
....print(line, end='') #display each line
....myList.append(line) #add the line to the list
#Close the file
myFile.close
print("\nFile should be closed now.\n")
print("Here's the contents of the list... \n")
#Display the contents of the list
for row in myList:
....print(row, end='') #entire rows
....print()
....for iCharacterIndex in range(len(row)):
........print(row[iCharacterIndex]) #character by character
p.s. I’ve put periods in to show the indentation, since it’s hard to get WordPress to preserve whitespace.
Security: Small is Beautiful
A Story
Imagine a new procedure for your next group event. First, I tell you that you have too much stuff, so leave all your bags — backpacks, jackets, etc. — on the sidewalk outside. Then I round up some friendly volunteers off the street, and pay them minimum wage to watch your belongings. Finally, I gather some more volunteers and send one to each of your homes to browse around while you’re not there.
With Too Much Personal Data, Security Is Broken
Sounds crazy, but this is the current situation with information security. With Moore’s Law to thank, we all have much more personal data — mostly photos and videos — than we can store and protect ourselves. So we put them “In The Cloud” on some provider’s remote server. Other personal information such as financial, medical, and government records, are stored at bank, hospital, and government data centers that don’t always do the greatest job of protecting them. (Think store credit card breaches.) Meanwhile, on the most common computer we all operate — the smartphone — we run apps written by strangers that ask permission to do just about anything on our phone. And we grant that permission.
Self-Securing to the Rescue
Is there any hope? I think there is — there has to be — but it’s not in more network firewalls or PC antivirus programs. (Still, better keep those running until better alternatives are available!)
Here’s what I see as trends for a 3+1 solution:
- Firewalls not per network, but per application: protecting itself against virus infiltration and data theft
- Every task individually sandboxed, so that no task can be hijacked to do hackers’ bidding
- All data encrypted so even if it’s stolen or intercepted, it’s not useful or public
All these methods are available, some even with operating system support and commercial products.
The “+1”: Authentication
With every application and file locked down from the wrong people, the rightful owners still need access. So we need reliable, personal, easy-to-use authentication as well. Biometrics seems to be the way to go, but it has to be distributed back to the owners — each of us — otherwise we’re just creating another central database waiting to be stolen.
Challenges
While these technologies are on the way, there are still challenges from competing interests and behaviors.
One is governments — even the ones trying to protect us. The first encrypted e-mail service shut down rather than submit to government surveillance, and a second one followed soon after, even without any immediate legal threats.
The other is us — businesses and clients not ready to do our part for personal information security. I could mention easy-to-guess passwords, but here’s a better example. The other day I received a personal file by e-mail from an insurance company. The file was attached, encrypted. Sounds fine, right? Except the insurance company’s software generates the e-mails with (a) the encrypted file attached; (b) the text of the unencrypted e-mail saying that the password is my id number and (c) my id number in the subject of the e-mail!
My Prediction
It’s going to take a while, and more denial of service events and data breaches, but the current situation is untenable. Governments and the information security industry, including big players and startups, will work together to develop and deploy standards, and easy-to-use systems, that delegate security to each application and file, and authentication to each legitimate user.
Until then, go outside to the sidewalk and see if your stuff is still there where you left it.
I presented these thoughts at the recent CyberJLM #3 in a 5-minute, no-slides, lightning talk format.
Agile Revolution Breaks Into Business and Life
Agile has been transforming software organizations one by one since the turn of the millenium.
Quadrupling productivity while making people and teams happier.
Modern work and life is knowledge-oriented, fast, and ever-changing. That’s what Agile addresses.
Why doesn’t anyone outside of software development adopt it?
Steve Denning, in a 2012 Forbes Magazine article, called it The Best-Kept Management Secret On The Planet.
It’s still pretty secret, but it shouldn’t be. The word “software” appears only once in the four statements of the Agile Manifesto. Three times in the Principles of Agile. Just replace “software” with “anything”.
Need confirmation? Try Ana Willem’s Should Non-technical Organizations model Agile principles? (no brainer).
So who’s doing it? Who is being Agile in their business or their life?
Here are the very few examples I’ve found so far:
- School: eduScrum
- University: The J-School Scrum: Bringing Agile Development Into the Classroom
- Job Search: Manage Your Job Search
Can you share more?
Talk About Quality 
